#include "dotenv.h"
#define TASK_MANAGER_IMPL
#include "task_manager.h"
#include <iostream>
#include "minilog.h"
#include "debug_any.hpp"

int main()
{

    minilog::log_info("hello, the answer is {}", 42);
    minilog::log_critical("this is right-aligned [{:>+10.04f}]", 3.14);

    minilog::log_warn("good job, {1:.5s} for making {0}", "minilog", "archibate");
    minilog::set_log_level(minilog::log_level::trace); // default log level is info
    // minilog::set_log_file("mini.log"); // uncomment to dump log to a specific file

    int my_variable = 42;
    MINILOG_P(my_variable); // shown when log level lower than debug

    minilog::log_trace("below is the color show :)");
#define _FUNCTION(name) minilog::log_##name(#name);
    MINILOG_FOREACH_LOG_LEVEL(_FUNCTION)
#undef _FUNCTION
debug(), "my variable is", my_variable;
    /// dotenv usage
    // dotenv::init();

    // std::cout << std::getenv("DATABASE_USERNAME") << std::endl;
    // std::cout << std::getenv("DATABASE_PASSWORD") << std::endl;

    /// task_manager usage
    // Example 1
    // auto res = task_manager::task<int>([]() { 
    //     return 100; 
    // })
    // #ifdef TASK_MANAGER_IMPL
    // .then([](int n) {
    //     return std::to_string(n);
    // }).then([](const std::string& str) {
    //     std::cout << str << std::endl;
    //     return std::atoi(str.c_str());
    // }).then([](int n) {
    //     ++n;
    //     std::cout << n << std::endl;
    //     return "done";
    // })
    // .run();
    // std::cout << res << std::endl; // done
    // #else
    // ;
    // #endif

    // Example 2
    // task_manager::delayed_task task([] {
    //     std::cout << "Delayed task executed!" << std::endl;
    // }, std::chrono::milliseconds(2000));

    // std::cout << "Task scheduled..." << std::endl;
    // task.run();
    // std::cout << "Task completed." << std::endl;

    // Example 3
    // task_manager::priority_task_manager manager;
    // manager.add_task(1, [] { std::cout << "Low priority task" << std::endl; });
    // manager.add_task(3, [] { std::cout << "High priority task" << std::endl; });
    // manager.add_task(2, [] { std::cout << "Medium priority task" << std::endl; });

    // manager.run_highest_priority_task();
    // manager.run_highest_priority_task();
    // manager.run_highest_priority_task();

    // Example 4
    //  task_manager::progress_task task(
    //     [](auto progress_cb) {
    //         for (int i = 0; i <= 100; i += 20) {
    //             progress_cb(i / 100.0);
    //             std::this_thread::sleep_for(std::chrono::seconds(1));
    //         }
    //     },
    //     [](double progress) {
    //         std::cout << "Progress: " << progress * 100 << "%" << std::endl;
    //     }
    // );
    // task.run();
    // std::cout << "Task completed." << std::endl;

    // Example 5
    // task_manager::cancelable_task task([] {
    //     static int count = 0;
    //     count++;
    //     std::cout << "Task running: " << count << std::endl;
    //     return count < 10;
    // });
    // auto future = task.start();
    // std::this_thread::sleep_for(std::chrono::seconds(3));
    // task.cancel();
    // std::cout << "Task canceled." << std::endl;
    // future.wait();
    // std::cout << "Task completed." << std::endl;

    // Example 6
     // 创建任务
    // auto task1 = std::make_shared<task_manager::task_dependency>([] {
    //     std::cout << "Task 1 executed" << std::endl;
    // });

    // auto task2 = std::make_shared<task_manager::task_dependency>([] {
    //     std::cout << "Task 2 executed" << std::endl;
    // });

    // auto task3 = std::make_shared<task_manager::task_dependency>([] {
    //     std::cout << "Task 3 executed" << std::endl;
    // });

    // // 设置任务依赖
    // task2->add_dependency(task1.get());
    // task3->add_dependency(task2.get());

    // // 执行任务
    // task3->run();

    // Example 7
    // // 创建任务组
    // auto group1 = std::make_shared<task_manager::task_group>([] {
    //     std::cout << "Group 1 task executed" << std::endl;
    // });

    // auto group2 = std::make_shared<task_manager::task_group>([] {
    //     std::cout << "Group 2 task executed" << std::endl;
    // });

    // auto main_group = std::make_shared<task_manager::task_group>([] {
    //     std::cout << "Main group task executed" << std::endl;
    // });

    // // 添加子组
    // main_group->add_group(group1.get());
    // main_group->add_group(group2.get());

    // // 执行任务组
    // main_group->run_group();

    // Example 8
//  // 创建任务
//     auto task1 = std::make_shared<task_manager::sequential_task>([] {
//         std::cout << "Task 1 executed" << std::endl;
//     });

//     auto task2 = std::make_shared<task_manager::sequential_task>([] {
//         std::cout << "Task 2 executed" << std::endl;
//     });

//     auto task3 = std::make_shared<task_manager::sequential_task>([] {
//         std::cout << "Task 3 executed" << std::endl;
//     });

//     // 设置任务顺序
//     task1->add_task(task2.get());
//     task2->add_task(task3.get());

//     // 执行任务序列
//     task1->run_sequence();


    // Example 9
    // task_manager::task_scheduler scheduler;

    // // 安排任务
    // scheduler.schedule([] {
    //     std::cout << "Task 1 executed" << std::endl;
    // }, std::chrono::milliseconds(1000));

    // scheduler.schedule([] {
    //     std::cout << "Task 2 executed" << std::endl;
    // }, std::chrono::milliseconds(2000));

    // // 启动调度器
    // scheduler.start();

    // // 等待一段时间以观察任务执行
    // std::this_thread::sleep_for(std::chrono::seconds(3));

    // Example 10
    // task_manager::task_analyzer task([] {
    //     std::this_thread::sleep_for(std::chrono::milliseconds(100));
    //     std::cout << "Task executed" << std::endl;
    // });

    // // 运行任务并分析结果
    // task.run();
    // task.analyze();

    // Example 11
    //  task_manager::concurrent_task_scheduler scheduler;

    // // 安排多个任务
    // for (int i = 0; i < 10; ++i) {
    //     scheduler.schedule([i] {
    //         std::cout << "Task " << i << " executed on thread " << std::this_thread::get_id() << std::endl;
    //         std::this_thread::sleep_for(std::chrono::milliseconds(100));
    //     });
    // }

    // // 等待一段时间以观察任务执行
    // std::this_thread::sleep_for(std::chrono::seconds(2));
 
    // Example 12
    // task_manager::thread_pool pool;

    // // 提交多个任务
    // for (int i = 0; i < 10; ++i) {
    //     pool.enqueue([i] {
    //         std::cout << "Task " << i << " executed on thread " << std::this_thread::get_id() << std::endl;
    //         std::this_thread::sleep_for(std::chrono::milliseconds(100));
    //     });
    // }

    // // 等待一段时间以观察任务执行
    // std::this_thread::sleep_for(std::chrono::seconds(2));
 
    // Example 13
    //  task_manager::thread_safe_task_chain<int> chain;

    // // 构建任务链
    // chain.start_chain([](int x) {
    //     std::cout << "First task: " << x << std::endl;
    //     return x * 2;
    // });

    // chain.then([](int x) {
    //     std::cout << "Second task: " << x << std::endl;
    //     return x + 10;
    // });

    // // 在多个线程中执行任务链
    // std::vector<std::thread> threads;
    // for (int i = 0; i < 5; ++i) {
    //     threads.emplace_back([&chain, i] {
    //         int result = chain.execute_chain(i);
    //         std::cout << "Result: " << result << std::endl;
    //     });
    // }

    // for (auto& thread : threads) {
    //     thread.join();
    // }

    // Example 14
    //  task_manager::thread_safe_task_analyzer analyzer;
    // std::vector<std::thread> threads;

    // // 提交多个任务进行分析
    // for (int i = 0; i < 10; ++i) {
    //     threads.emplace_back([&analyzer, i] {
    //         analyzer.analyze_task([i] {
    //             std::cout << "Task " << i << " executed on thread " << std::this_thread::get_id() << std::endl;
    //             std::this_thread::sleep_for(std::chrono::milliseconds(100));
    //         });
    //     });
    // }

    // // 等待所有任务完成
    // for (auto& thread : threads) {
    //     thread.join();
    // }

    // // 打印统计信息
    // analyzer.print_statistics();


    // Example 15
    // task_manager::persistent_task manager("tasks.json");

    // // 提交任务
    // manager.enqueue([] {
    //     std::cout << "Task 1 executed" << std::endl;
    //     std::this_thread::sleep_for(std::chrono::milliseconds(500));
    // });

    // manager.enqueue([] {
    //     std::cout << "Task 2 executed" << std::endl;
    //     std::this_thread::sleep_for(std::chrono::milliseconds(500));
    //     throw std::runtime_error("Task 2 failed intentionally");
    // });

    // // 运行所有任务
    // manager.run_all();

    // // 打印任务状态
    // manager.print_task_status(1);
    // manager.print_task_status(2);

    // Example 16
    //  task_manager::task_with_retry task([] {
    //     static int attempt = 0;
    //     attempt++;
    //     if (attempt < 3) {
    //         std::cout << "Attempt " << attempt << ": Task failed" << std::endl;
    //         throw std::runtime_error("Task failed intentionally");
    //     }
    //     std::cout << "Attempt " << attempt << ": Task succeeded" << std::endl;
    // }, 3, std::chrono::milliseconds(500));

    // task.run();


   
    return 0;
}